Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/embed/tei.rs">

<violation number="1" location="crates/noxa-rag/src/embed/tei.rs:173">
P2: The reduced-batch retry path swallows the real sub-batch error and always returns a synthetic 413 error, causing incorrect failure reporting.</violation>
</file>

<file name="crates/noxa-rag/src/pipeline.rs">

<violation number="1" location="crates/noxa-rag/src/pipeline.rs:263">
P1: IPv6 private address check only covers loopback, missing unique-local (`fc00::/7`) and link-local (`fe80::/10`). A URL with a private IPv6 address like `http://[fd00::1]/...` would pass validation. Add manual octet checks for these ranges.</violation>
</file>

<file name="crates/noxa-rag/src/store/qdrant.rs">

<violation number="1" location="crates/noxa-rag/src/store/qdrant.rs:158">
P1: `upsert` stores raw URLs while `delete_by_url` matches normalized URLs, which can break delete-before-upsert for equivalent URL forms.</violation>
</file>

<file name="crates/noxa-rag/src/factory.rs">

<violation number="1" location="crates/noxa-rag/src/factory.rs:82">
P1: Existing Qdrant collections are not dimension-validated at startup, so incompatible vector sizes are only discovered later during upserts.</violation>
</file>

<file name="crates/noxa-rag/src/chunker.rs">

<violation number="1" location="crates/noxa-rag/src/chunker.rs:48">
P2: The overlap builder can return more than `overlap_tokens` because it checks the token budget after inserting the next word and breaks without undoing that insertion.</violation>
</file>

<file name="crates/noxa-rag/README.md">

<violation number="1" location="crates/noxa-rag/README.md:72">
P1: README points users to Qdrant gRPC port 6334, but this crate uses HTTP REST endpoints and expects port 6333. The documented config URL will not work.</violation>
</file>

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/pipeline.rs">

<violation number="1" location="crates/noxa-rag/src/pipeline.rs:247">
P1: Do not call `std::process::exit(0)` from library shutdown logic; return an error instead so callers can handle timeout safely.</violation>
</file>

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/noxa-rag/README.md`:
- Line 7: The README currently states Qdrant is running on gRPC port 6334 but
the crate uses Qdrant REST via reqwest; update every README occurrence (the
lines referencing gRPC/6334) to reflect REST/HTTP usage and the correct default
REST port (6333) and/or the full REST URL format used by this crate; refer to
src/config.rs for the canonical REST URL/config keys (so the README and the
implementation agree) and replace "gRPC/6334" wording with "HTTP REST (default
port 6333) / REST URL as configured in src/config.rs".
- Line 133: The README contains an unlabeled fenced code block (the block
starting with the lines containing "noxa-cli (writes .json) → watch_dir ...")
which triggers markdownlint MD040; update that fenced block to include a
language identifier (e.g., add "text" after the opening ``` so it becomes
```text) to explicitly label the block and satisfy the linter while leaving the
block content unchanged.

In `@crates/noxa-rag/src/chunker.rs`:
- Around line 45-49: The overlap-building loop currently inserts each word into
selected before checking token_estimate, so the first word that pushes the
estimate over overlap_tokens is retained; fix by checking the candidate's token
count before finalizing the insertion or by inserting then removing the last
word if the estimate >= overlap_tokens. Update the loop around
selected.insert(0, word) / selected.join(" ") to compute the candidate with the
prospective word and only keep it (or break) when token_estimate(&candidate,
tokenizer) < overlap_tokens, ensuring the overlap prefix stays within the
configured budget; reference the variables/functions words, selected,
token_estimate, tokenizer, and overlap_tokens when making the change.

In `@crates/noxa-rag/src/embed/tei.rs`:
- Around line 69-75: The code currently sets `dimensions` to
`DEFAULT_DIMENSIONS` when the deserialized `vecs` is empty, which can mask a bad
TEI probe; update the logic around `let vecs: Vec<Vec<f32>> =
resp.json().await?;` and `dimensions` so that if `vecs.is_empty()` you return an
error (or use `anyhow::bail!` / `Err(...)`) instead of falling back to
`DEFAULT_DIMENSIONS`, providing a clear error message that the TEI probe
returned an empty embedding response; adjust callers of this function to
propagate the error as needed.
- Around line 166-184: Replace the brittle string-match and synthetic-error
masking: stop checking Err(RagError::Embed(ref msg)) if msg.contains("413") and
instead detect a real 413 response via a dedicated status or variant on RagError
(e.g., add/ use a RagError::HttpStatus(u16) or include a status_code field on
RagError::Embed) so the fallback is only triggered for an actual 413; and when
iterating sub_chunk results from self.embed_batch(...) do not throw away the
original error—propagate Err(e) back to the caller instead of converting it into
a fabricated "TEI returned 413 even on reduced batch size" message (i.e.,
preserve and return the original Err from embed_batch when it fails).

In `@crates/noxa-rag/src/factory.rs`:
- Around line 17-34: The current check using provider.dimensions() can miss the
case where TeiProvider::new_with_probe() fell back to DEFAULT_DIMENSIONS because
the /embed probe returned no vectors; to fix this, after the availability check
call the provider.embed(...) probe (using the same small test input used by
TeiProvider::new_with_probe or a single-token input) and inspect the returned
vector(s) to ensure they are non-empty and derive actual dimensions; if the
embed response contains no vectors or zero-length vectors return
Err(RagError::Config(...)) instead of accepting the provider. Reference
TeiProvider::new_with_probe, provider.is_available(), provider.embed(), and
provider.dimensions() when locating where to add the re-probe and validation.
- Around line 81-96: The startup currently only warns when a collection exists
but may have mismatched vector dims; implement an explicit check in
build_vector_store(): when store.collection_exists() returns true, call a new
QdrantStore::collection_info() (returning CollectionInfoResponse) to fetch GET
/collections/{collection_name}, extract the stored vectors.size, compare it to
embed_dims, and return an Err if they differ (instead of logging a warning);
keep the existing create_collection(embed_dims) path for the false branch.
Ensure you add collection_info() to QdrantStore, parse the response into
CollectionInfoResponse, and use the collection and embed_dims identifiers from
the current scope for clear error logging.

In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 396-423: The code constructs UUIDs, PointPayload.url, and uses the
url_locks key from the raw extracted URL, but delete_by_url and PointPayload.url
are expected to use a normalized/canonical URL; normalize the URL once up front
and use that canonical value everywhere: replace uses of the raw `url` when
calling `uuid::Uuid::new_v5(...)`, when setting `PointPayload { url: ... }`, and
when accessing `url_locks.entry(...)`/locking, and pass the same canonical URL
into `store.delete_by_url(&...)` and `store.upsert(points)` so IDs, payloads,
and the per-URL mutex all align with `delete_by_url`'s normalization logic.
- Around line 422-423: The current replace deletes existing vectors first
(store.delete_by_url(&url).await?) and then upserts new points, which can cause
data loss if upsert fails; change to a two-phase replace: first upsert the new
points (store.upsert(points).await?) using a new generation/version tag or
temporary ID, verify success, then remove the old vectors
(store.delete_by_url(&url).await?) or delete only entries with the previous
generation ID; alternatively, if the store supports transactions or conditional
deletes, perform the upsert and deletion atomically or use versioned IDs (e.g.,
attach generation/version to points) and run a stale-ID cleanup after successful
upsert to ensure transient failures don’t make data disappear.
- Around line 261-264: The IPv6 branch of is_private_ip only checks
is_loopback(), letting IPv6 unique-local and link-local addresses pass; update
the match arm in is_private_ip (the IpAddr::V6 branch) to also call
is_unique_local() and is_unicast_link_local() so it mirrors the IPv4 checks
(i.e., include ip.is_unique_local() || ip.is_unicast_link_local() alongside
is_loopback()).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/noxa-rag/src/bin/noxa-rag-daemon.rs`:
- Around line 103-112: The probe call that computes embed_dims is redundant
because build_embed_provider already probes during TeiProvider::new_with_probe;
change build_embed_provider to return the discovered dimension alongside the
provider (e.g., return (DynEmbedProvider, usize)) and update the caller in
noxa-rag-daemon.rs to destructure that tuple (replace the embed + probe block
with let (embed, embed_dims) = build_embed_provider(&config).await?). Update
TeiProvider (or the provider wrapper) to expose dimensions via a dimensions()
accessor if needed so build_embed_provider can obtain and return the usize.

In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 236-249: The forced shutdown on worker drain timeout currently
calls std::process::exit(0) which reports a successful exit despite the abnormal
condition; change the exit to a non-zero code (e.g., std::process::exit(1)) so
supervisors can detect the failure. Locate the timeout handling around
tokio::time::timeout(Duration::from_secs(10), drain).await where the Err(_)
branch logs "workers did not drain within 10s, forcing exit" and replace the
exit status there; ensure the surrounding symbols (drain async block and
worker_handles) remain unchanged.

---

Duplicate comments:
In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 264-273: The function is_private_ip currently checks only IPv6
loopback addresses and thus lets IPv6 unique-local (fc00::/7) and link-local
(fe80::/10) addresses through; update the IPv6 branch in is_private_ip to also
return true for ip.is_unique_local() and ip.is_unicast_link_local() (in addition
to is_loopback()) so IPv6 validation mirrors the IPv4 checks
(private/link-local/loopback).
- Around line 398-421: The UUID and PointPayload.url are being derived from raw
chunk.source_url; change the mapping in the points builder (where
uuid::Uuid::new_v5 is called and PointPayload.url is set) to use the normalized
URL variable (the same normalized value used for the mutex key/delete_by_url
logic) instead of chunk.source_url so UUIDs and payload URLs are consistent with
deletes; keep using config.uuid_namespace for UUID v5 but pass the normalized
URL string into format!("{}#chunk{}", normalized_url, i) and set
PointPayload.url = normalized_url.clone().
- Around line 423-433: The current delete-then-upsert under the per-URL mutex
(url_locks, url_lock) can cause permanent data loss if store.delete_by_url(&url)
succeeds but store.upsert(points) fails; either document this behavior in the
pipeline logic or change to a two-phase replace: generate a new generation tag
(e.g., generation_id) for the incoming points, call
store.upsert(points_with_generation) under the same mutex, then call a targeted
delete that removes only older generations (or delete_by_url_except_generation)
so an upsert failure does not remove the previous vectors; update any helper
methods (store.upsert, store.delete_by_url or add
delete_by_generation/cleanup_old_generations) and keep the same url_lock around
both operations to retain atomicity semantics.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/noxa-rag/src/bin/noxa-rag-daemon.rs`:
- Around line 175-177: The pipeline error is being printed but the program still
returns Ok(()), so failures don't set a non-zero exit code; modify the code
around pipeline.run().await to propagate the error instead of swallowing
it—either return Err(e.into()) from main (or use the ? operator on
pipeline.run().await) so the process returns a non-zero exit status, or
explicitly call std::process::exit(1) after logging; locate the
pipeline.run().await call and adjust its handling to propagate the error (e.g.,
change the if let Err(e) = pipeline.run().await { ... } block to use ? or return
Err(e.into())).
- Around line 110-115: The match on config.embed_provider sets tokenizer_model
with a fallback branch that is unreachable because build_embed_provider returns
Err for non-Tei providers; update the match in noxa-rag-daemon.rs so the non-Tei
case is explicit: either remove the unreachable "_ => ..." fallback and instead
handle other variants of EmbedProviderConfig explicitly (e.g., match
EmbedProviderConfig::OpenAI | EmbedProviderConfig::VoyageAI => return Err or
panic with a clear message), or change the binding to return an Option/Result so
callers handle absence; target the tokenizer_model binding and the
EmbedProviderConfig::Tei arm when making this change.

In `@crates/noxa-rag/src/chunker.rs`:
- Around line 82-88: The chunker stores the raw result.metadata.url into
source_url (and uses extract_domain) while the pipeline normalizes URLs into a
local url variable but still uses chunk.source_url when building
PointPayload.url and generating UUIDs, causing mismatches with delete_by_url
which normalizes before filtering; fix by making URL normalization consistent:
either normalize and store the canonical URL in chunk.source_url in the chunker
(replace result.metadata.url -> normalized URL using the same normalization used
by delete_by_url) or update the pipeline to always use the normalized url
variable (not chunk.source_url) when generating UUIDs and setting
PointPayload.url; ensure the same normalization function is used in both places
so extract_domain, PointPayload.url, uuid generation, and delete_by_url all
operate on the identical canonical URL.

In `@crates/noxa-rag/src/embed/tei.rs`:
- Around line 138-141: The retry backoff currently caps at 400ms by using
(delay_ms * 2).min(400) inside the retry loop that checks status and
MAX_RETRIES; update this to a larger or configurable cap: replace the hardcoded
400 with a constant or config variable (e.g., BACKOFF_MAX_MS or a field on the
client) and use (delay_ms * 2).min(backoff_max_ms) so callers can raise the cap
for aggressive 429 handling; ensure the new constant/config is used where
delay_ms is initialized and documented/tested.

In `@crates/noxa-rag/src/store/qdrant.rs`:
- Around line 31-34: The current CollectionVectors struct assumes the Qdrant
response has an unnamed vectors object with a direct size field, which breaks
for named-vector responses; update parsing used in collection_vector_size() to
accept both shapes by replacing CollectionVectors with a deserializable type
that handles either { "size": ... } or a map of named vectors (e.g.,
HashMap<String, VectorInfo>) or implement a custom Deserialize for
CollectionVectors that checks if the value is an object with "size" or an object
of named entries and then extracts a size; reference the CollectionVectors type
and the collection_vector_size() callsite so the deserializer change will be
used there.
- Around line 265-282: The current filter_map in the block that builds results
(the closure using hit.payload, extracting "text" and "url" and constructing
SearchResult) silently drops hits with missing fields; change this to explicitly
detect missing or malformed payload fields, log a warning with the hit id/score
and which field(s) were missing (use the existing logging/tracing facility in
the crate, e.g., tracing::warn! or log::warn!), and then skip the hit rather
than silently discarding it; update the closure around hit.payload /
payload.get("text") / payload.get("url") to record the missing-field details
before returning None and still construct SearchResult as before when all fields
are present.

---

Duplicate comments:
In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 405-423: The UUID generation and payload URL currently use
chunk.source_url inside the map closure (where uuid::Uuid::new_v5 is called and
PointPayload.url is set), causing mismatches with delete_by_url which uses a
normalized url; update the map to use the already-computed normalized url
variable (from earlier in the scope) for both the new_v5 namespace input and
PointPayload.url so UUIDs and stored URLs are consistent with delete_by_url
filtering (keep other payload fields unchanged and continue cloning vector/text
as before).

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/pipeline.rs">

<violation number="1" location="crates/noxa-rag/src/pipeline.rs:452">
P2: The new `remove_if` eviction condition never matches because the local `url_lock` clone is still held, so lock entries are not cleaned up.</violation>
</file>

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 429-456: After acquiring the mutex (url_lock / _guard) ensure the
DashMap entry is evicted on all return paths: if store.delete_by_url or
store.upsert fails you must drop the guard and the local Arc clone and call
url_locks.remove_if(&url, |_, v| Arc::strong_count(v) == 1) before returning the
error. Update the error branches around store.delete_by_url() and the upsert()
failure path (the block that logs "upsert failed after delete") to perform
drop(_guard); drop(url_lock); url_locks.remove_if(&url, |_, v|
Arc::strong_count(v) == 1); then return Err(e) so failed attempts don't leak
url_locks entries.
- Around line 153-177: The intermediate unbounded std::sync::mpsc::channel
(notify_tx/notify_rx) lets the debouncer emit events without backpressure —
replace it with a bounded channel (e.g., std::sync::mpsc::sync_channel) with a
small capacity or change the debouncer's event handler to call blocking_send()
directly so the debouncer will block when the Tokio tx (used in blocking_send)
is backpressured; update the code that constructs the debouncer via
new_debouncer and the bridge task (bridge_handle) to use the bounded
notify_tx/notify_rx (or to remove the intermediate channel and call
tx.blocking_send from the debouncer callback) so memory cannot grow unbounded
during filesystem churn.

In `@crates/noxa-rag/src/store/qdrant.rs`:
- Around line 95-98: The reqwest client built in qdrant.rs (the variable client
from reqwest::Client::builder()) lacks any timeouts causing operations to
potentially hang; update the builder to set sensible timeouts (e.g.,
connect_timeout and overall request timeout via
connect_timeout(Duration::from_secs(...)) and timeout(Duration::from_secs(...)))
before calling build(), so all collection/search/delete/upsert requests using
this client will be bounded; preserve the existing
map_err(RagError::Config(...)) behavior when calling build().

---

Duplicate comments:
In `@crates/noxa-rag/src/embed/tei.rs`:
- Around line 130-135: The error handling currently embeds HTTP status info into
freeform strings and other code (e.g., the embed_batch() caller) detects 413 by
checking msg.contains("413"); change RagError so it carries structured status
data (e.g., add a variant or field like RagError::Embed { message: String,
status: Option<u16> } or similar), return that structured error where you detect
status.as_u16() == 413 in embed_batch(), and update all call sites that check
for "413" in the error string to instead match on the new status field (match
RagError::Embed { status: Some(413), .. } ). Ensure both the 130–135 and 164–170
error returns populate the status field.

In `@crates/noxa-rag/src/store/qdrant.rs`:
- Around line 31-34: collection_vector_size() currently only deserializes the
single-vector shape into CollectionVectors { size } and will fail when Qdrant
returns a named-vector schema; change the parsing to first try the existing
CollectionVectors path and, if that fails, attempt deserializing the "vectors"
field as a map of named configs (e.g., a temporary CollectionNamedVectors {
vectors: HashMap<String, CollectionVectors> }) then extract the vector size(s)
(ensure either all named vectors have the same size or pick the appropriate
named vector according to existing logic) and use that size for the dimension
comparison; apply the same dual-deserialization fix wherever the same logic is
duplicated (the other block referenced in the review) so both single-vector and
named-vector responses are accepted.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 94-103: Reject or clamp embed_concurrency before creating the job
channel and spawning workers: check self.config.pipeline.embed_concurrency and
if it is 0 either return an error (fail fast) or set it to 1, so the bounded
channel (tx/rx) and worker pool loop (for worker_id in
0..self.config.pipeline.embed_concurrency) always has at least one worker to
drain jobs; update the code around the channel creation and the
worker_handles/for loop to use the validated/clamped value.
- Around line 211-246: The bridge uses tx_clone.blocking_send(job) which can
block indefinitely and prevent prompt shutdown; replace it with a
cancellation-aware loop that calls tx_clone.try_send(job) and handles
TrySendError: on Ok -> break out of the loop; on Full -> check
shutdown_clone.is_cancelled() and if cancelled break/return, otherwise
sleep/yield briefly (e.g., thread::sleep or std::thread::yield_now) and retry;
on Disconnected -> break/return. Keep the rest of the bridge logic
(shutdown_clone, drop(tx), bridge_handle.await) unchanged so the bridge can exit
immediately when cancellation is requested.

In `@crates/noxa-rag/src/store/qdrant.rs`:
- Around line 189-218: The upsert() implementation currently upserts in
256-point chunks and returns on first failed batch, leaving earlier successful
chunks persisted and potentially causing partial documents; modify upsert() (the
loop building QdrantPoint batches and sending UpsertRequest via self.client.put)
to be atomic for a single logical document: either (recommended) avoid chunking
per logical document by sending all points for that URL in one UpsertRequest, or
(if chunking must be kept) track the IDs successfully written per chunk and on
any failure call the Qdrant delete-by-ids API (via self.client) to remove those
IDs before returning Err(RagError::Store(...)); ensure you reference the same
QdrantPoint.id values when deleting and propagate the original error text in the
returned RagError.

---

Duplicate comments:
In `@crates/noxa-rag/src/pipeline.rs`:
- Around line 447-476: The current delete-then-upsert in the async block
(store.delete_by_url(&url).await?; store.upsert(points).await) is not atomic; if
upsert fails you temporarily lose or partially lose the document. Change to a
versioned / two-phase replace: produce a new versioned document (or batch) and
call store.upsert for the new version first, then atomically retire the old
version (e.g., delete_by_url_excluding_version or conditional delete), or use a
conditional/compare-and-swap upsert API if the store supports it. Update the
logic around store.upsert, store.delete_by_url, and store_result so you upsert
new data before removing the old, ensure the eviction/drop of _guard and
url_locks remains unchanged, and add any version metadata handling required by
the store implementation to make replace idempotent and safe on failures.

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/embed/tei.rs">

<violation number="1" location="crates/noxa-rag/src/embed/tei.rs:63">
P2: The `max retries exceeded` error block is unreachable because the loop always returns before reaching it.</violation>
</file>

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/embed/tei.rs">

<violation number="1" location="crates/noxa-rag/src/embed/tei.rs:117">
P2: Off-by-one retry regression: `MAX_RETRIES` now limits total attempts instead of retries, so 429/503 responses get one fewer retry than configured.</violation>
</file>

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/store/qdrant.rs">

<violation number="1" location="crates/noxa-rag/src/store/qdrant.rs:147">
P1: Avoid byte-slicing error text; it can panic on non-ASCII UTF-8 and crash error handling.</violation>

<violation number="2" location="crates/noxa-rag/src/store/qdrant.rs:174">
P2: Do not create `content_type`/`file_format` indexes until those payload fields are written or queried; currently they add index build cost with no benefit.</violation>
</file>

<file name="crates/noxa-fetch/src/document.rs">

<violation number="1" location="crates/noxa-fetch/src/document.rs:114">
P2: Document responses fetched over HTTP are incorrectly labeled as `source_type = "file"`; they should be `"web"` for correct provenance.</violation>
</file>

<file name="crates/noxa-rag/src/embed/tei.rs">

<violation number="1" location="crates/noxa-rag/src/embed/tei.rs:172">
P1: Slicing the response body with `&body[..min(512)]` can panic on non-ASCII UTF-8 text; use a char-boundary-safe truncation for error previews.</violation>
</file>

<file name="crates/noxa-rag/src/pipeline.rs">

<violation number="1" location="crates/noxa-rag/src/pipeline.rs:153">
P3: `files_indexed` is incremented for skipped jobs (0-chunk `Ok` paths), so indexed/average session metrics are inflated and inaccurate.</violation>
</file>

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/pipeline.rs">

<violation number="1" location="crates/noxa-rag/src/pipeline.rs:592">
P2: Binary formats (`.pdf`, `.docx`, `.odt`, `.pptx`) accepted by `is_indexable` will fail at `read_to_string` with a UTF-8 error before the format dispatch is reached, bypassing the intended graceful "not yet supported" skip. Move the extension check before the content read, or gate `read_to_string` on the format being text-based.</violation>
</file>

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="crates/noxa-rag/src/pipeline.rs">

<violation number="1" location="crates/noxa-rag/src/pipeline.rs:363">
P2: Qdrant errors during the startup delta check are silently discarded. If Qdrant is unreachable or misconfigured, every file will be re-enqueued with zero diagnostic output. Log the error at `warn` level before falling through to the conservative re-enqueue path.</violation>

<violation number="2" location="crates/noxa-rag/src/pipeline.rs:852">
P2: The per-entry decompressed-size guard (`MAX_ENTRY_SIZE`) is bypassed for DOCX because the function returns early before the entry-iteration loop. Only the `MAX_ENTRIES` count check runs. If `noxa_fetch::document::extract_document` lacks its own decompressed-size guard, a crafted DOCX zip bomb could cause excessive memory use.</violation>
</file>